const fs = require('fs').promises;
const path = require('path');
const { program } = require('commander');

// 配置命令行参数
program
  .name('mp4-rename')
  .description('批量重命名 MP4 文件 - 将空格替换为连字符')
  .version('1.0.0')
  .requiredOption('-d, --directory <path>', '要处理的目录路径')
  .option('--dry-run', '执行干运行（只显示更改而不实际修改）')
  .option('--recursive', '递归处理子目录')
  .option('--verbose', '显示详细处理信息');

program.parse();
const options = program.opts();

// 替换文件名中的空格为连字符
function replaceSpaces(name) {
  name = name.replace(/-[1920x1080]/g, '')
  name = name.replace(/-[640x480]/g, '')
  let [newName] = name.split('-[');
  newName = newName.replace(/第(\d+)集/, (match, episodeNum) => {
    const paddedNum = parseInt(episodeNum).toString().padStart(2, '0');
    return `第${paddedNum}集`;
  })
  newName = newName.replace(/ /g, '')
  newName = newName.replace(/第/g, ' 第')
  return newName;
}

// 处理单个 MP4 文件
async function processMp4File(filePath) {
  try {
    const dir = path.dirname(filePath);
    const ext = path.extname(filePath);
    const baseName = path.basename(filePath, ext);
    
    // 只处理 MP4 文件
    if (ext.toLowerCase() !== '.mp4') {
      if (options.verbose) {
        console.log(`跳过非 MP4 文件: ${filePath}`);
      }
      return false;
    }
    
    const newBaseName = replaceSpaces(baseName);
    if (newBaseName === baseName) {
      if (options.verbose) {
        console.log(`无需重命名: ${filePath}`);
      }
      return false;
    }
    
    const newFilePath = path.join(dir, `${newBaseName}${ext}`);
    console.log(`重命名: ${filePath} → ${newFilePath}`);
    
    if (!options.dryRun) {
      await fs.rename(filePath, newFilePath);
      console.log(`✅ 操作完成`);
    }
    
    return true;
  } catch (err) {
    console.error(`❌ 处理文件 ${filePath} 时出错:`, err.message);
    return false;
  }
}

// 递归处理目录
async function processDirectory(dirPath) {
  try {
    const entries = await fs.readdir(dirPath, { withFileTypes: true });
    
    for (const entry of entries) {
      const entryPath = path.join(dirPath, entry.name);
      
      if (entry.isDirectory()) {
        if (options.recursive) {
          await processDirectory(entryPath);
        }
      } else {
        await processMp4File(entryPath);
      }
    }
  } catch (err) {
    console.error(`❌ 处理目录 ${dirPath} 时出错:`, err.message);
  }
}

// 主函数
async function main() {
  const directory = path.resolve(options.directory);
  
  try {
    // 检查目录是否存在
    const stat = await fs.stat(directory);
    if (!stat.isDirectory()) {
      console.error(`❌ 错误: 指定的路径不是目录: ${directory}`);
      process.exit(1);
    }
    
    console.log(`开始处理目录: ${directory}`);
    console.log(`递归模式: ${options.recursive ? '启用' : '禁用'}`);
    console.log(`干运行模式: ${options.dryRun ? '启用' : '禁用'}`);
    console.log(''.padEnd(50, '-'));
    
    await processDirectory(directory);
    console.log('处理完成');
  } catch (err) {
    if (err.code === 'ENOENT') {
      console.error(`❌ 错误: 指定的目录不存在: ${directory}`);
    } else {
      console.error('❌ 发生未知错误:', err.message);
    }
    process.exit(1);
  }
}

// 执行主函数
main();    